#ifndef TIPOINT_H_
#define TIPOINT_H_

/*****************************************************************
 *	tipo_int.h
 * 
 *  Descripcion: Clase que representa un tipo entero para un campo.
 *  Hereda de tipodato e implementa sus metodos.
 * **************************************************************/

#include "tipo_dato.h"
#include <limits.h>

class TipoInt : public TipoDato {
	
	//Atribs:
	private:
		static int invalido; //Determina el valor para campo int invalido
	
		int valor;
	
	public:
	
	/*
	 * Constructor con param: Crea un nuevo objeto TipoInt con el valor
	 * pasado por param. Los datos int siempre son obligatorios.
	 */
	TipoInt(const int &val);
	
	/*
	 * Contructor por defecto, inicializa el campo como invalido. 
	 */
	 TipoInt(); 
	
	//Metodos:
	
	/*
	 * Esta cargado: Devuelve true si el dato esta cargado,
	 * false en caso contrario.
	 */
	virtual bool esta_cargado() const;
	
	/* 
	 * Op de insercion: Permite asignar un valor al objeto del tipodato.
	 * Verifica que el dato pasado por param sea int.
	 * Si hay problemas con el casteo tira una excep.
	 */
	virtual TipoDato& operator= (const TipoDato& dato) throw (ExcepErrorTipos);
	
	/*
	 * Op de insc con int: Asigna un valor int al objeto actual.
	 */
	TipoInt& operator= (const int &valor);
	
	/*
	 * Get Valor: Devuelve el entero contenido dentro del objeto tipo int.
	 */
	int get_valor();
	
	/*
	 * Op de igualacion: Devuelve true si los valores de los datos son
	 * iguales, false en caso contrario.
	 * Verifica que el dato pasado por param sea int.
	 * Si hay problemas con el casteo tira una excep.
	 */
	virtual bool operator== (const TipoDato& dato) const throw (ExcepErrorTipos);
	
	/*
	 * Op <: Devuelve true si el valor del dato actual es menor al del
	 * pasado por param, false en caso contrario.
	 * Verifica que el dato pasado por param sea int.
	 * Si hay problemas con el casteo tira una excep.
	 */
	virtual bool operator< (const TipoDato& dato) const throw (ExcepErrorTipos);
		
	/*
	 * Get Codigo Tipo: Devuelve el codigo del tipo de dato en cuestion.
	 */
	virtual CodTipo get_codigo_tipo() const;
	
	/*
	 * Clonar: Devuelve la referencia a un nuevo dato con el mismo 
	 * contenido que el actual.
	 * El nuevo objeto es creado en heap y debe ser liberado.
	 */
	virtual TipoDato* clonar() const;
	
	/*
	 * ToStream: Dado un stream de salida, pasa la representacion del dato
	 * al mismo.
	 */
	virtual ostream& toStream(ostream& out) const;
	
	/*
	 * get_tamanio: Devuelve la cantidad de campos del tipo, es decir 1
	 */
	virtual unsigned int get_tamanio() const;
	
	/*
	 * Crea una cadena que contiene el dato serializado. La devuelve
	 * en retorno y asigna el tamano de la misma en tam
	 */ 
	virtual void serializar(char ** retorno, unsigned int &tam);
		
	/*
	 * Obtiene un tipo de dato a partir de los datos serializados.
	 * Debe recibir el tamano de tamano de la cadena de serializados.
	 * Devuelve true si pudo realizar bien la operacion, false en
	 * caso contrario
	 */ 
	virtual bool deserializar(char * serializados, unsigned int tam);
	
	/*
	 * Devuelve el tamano en bytes que ocupa serializado
	 */ 
	unsigned int get_tamanio_serializado();
};

#endif
